package com.qst.order.controller;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.qst.order.domain.DTO.*;
import com.qst.order.domain.Product;
import com.qst.order.domain.User;
import com.qst.order.service.OrderService;
import com.qst.order.service.ProductService;
import com.qst.order.service.UserService;
import com.qst.order.utils.Result;
import jakarta.validation.Valid;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDateTime;
import java.util.Map;


@RestController
@RequestMapping("/api/admin")
@RequiredArgsConstructor
@Slf4j
public class AdminController {

    private final UserService userService;
    private final PasswordEncoder passwordEncoder;
    private final OrderService orderService;
    private final ProductService productService;
    /**
     * 分页查询用户列表（支持搜索条件）
     * @param page 页码（默认1）
     * @param size 每页条数（默认6）
     * @param username 用户名（模糊搜索，可为空）
     * @param role 角色（精确匹配，0=管理员，1=商家，2=用户，可为空）
     * @param phone 手机号（模糊搜索，可为空）
     * @return 分页用户数据
     */
    @GetMapping("/getUserList") // 注意：前端调用的接口路径需与此一致
    public Result getRole(
            @RequestParam(defaultValue = "1") Integer page,
            @RequestParam(defaultValue = "6") Integer size,
            @RequestParam(required = false) String username,
            @RequestParam(required = false) Integer role,
            @RequestParam(required = false) String phone) {
        log.warn("用户名:{}", role);
        // 1. 创建分页对象
        IPage<User> userIPage = new Page<>(page, size);

        // 2. 构建查询条件
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        // 用户名模糊搜索
        if (username != null && !username.isEmpty()) {
            queryWrapper.like("username", username);
        }
        // 角色精确匹配
        if (role != null) {
            queryWrapper.eq("role", role);
        }
        // 手机号模糊搜索
        if (phone != null && !phone.isEmpty()) {
            queryWrapper.like("phone", phone);
        }

        // 3. 执行带条件的分页查询
        IPage<User> pageResult = userService.page(userIPage, queryWrapper);

        // 4. 返回结果（确保Result类能正确序列化分页数据）
        return Result.success(pageResult);
    }


    /**
     * 新增用户接口
     */
    @PostMapping("/addUser")
    @Transactional
    public Result addUser(@Valid @RequestBody User user) {
        // 1. 校验用户名是否已存在
        User existingUser = userService.findByUsername(user.getUsername());
        if (existingUser != null) {
            return Result.error("用户名已存在");
        }

        // 2. 密码加密
        String encryptedPwd = passwordEncoder.encode(user.getPassword());
        user.setPassword(encryptedPwd);

        // 3. 设置创建时间和默认状态
        user.setCreateTime(LocalDateTime.now());
        user.setStatus(1); // 默认启用

        // 4. 插入数据库（MyBatis-Plus的insert方法）
         userService.save(user);
        return Result.success("添加用户成功");
    }

    /**
     * 编辑用户接口
     */
    @PutMapping("/editUser")
    @Transactional
    public Result editUser(@Valid @RequestBody User user) {
        // 1. 校验用户是否存在
        if (user.getId() == null) {
            return Result.error("用户ID不能为空");
        }
        User existingUser = userService.getById(user.getId());
        if (existingUser == null) {
            return Result.error("用户不存在");
        }

        // 2. 处理密码（为空则不更新，否则加密）
        if (user.getPassword() == null || user.getPassword().trim().isEmpty()) {
            // 密码为空：保留原有密码
            user.setPassword(existingUser.getPassword());
        } else {
            // 密码不为空：加密后更新
            user.setPassword(passwordEncoder.encode(user.getPassword()));
        }

        // 3. 禁止修改创建时间（保持原有值）
        user.setCreateTime(existingUser.getCreateTime());

        // 4. 更新数据库（MyBatis-Plus的updateById方法）
        boolean rows = userService.updateById(user);
        return rows ? Result.success("更新用户成功") : Result.error("更新用户失败");
    }


    /**
     * 修改用户状态（启用/禁用）
     * 前端请求：PUT /api/admin/changeUserStatus，请求体 {id: 1, status: 0}
     */
    @PutMapping("/changeUserStatus")
    public Result changeUserStatus(@Valid @RequestBody StatusUpdateDTO dto) {
        // 1. 校验状态值合法性（只能是 0 或 1）
        if (dto.getStatus() != 0 && dto.getStatus() != 1) {
            return Result.error("状态值无效，只能是 0（禁用）或 1（启用）");
        }

        // 2. 检查用户是否存在
        User user = userService.getById(dto.getId());
        if (user == null) {
            return Result.error("用户不存在");
        }

        // 3. 如果状态未变更，直接返回成功（优化：减少数据库操作）
        if (user.getStatus()==dto.getStatus()) {
            return Result.success("状态未变更");
        }

        // 4. 使用 MyBatis-Plus 的 UpdateWrapper 执行更新（只更新 status 字段）
        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("id", dto.getId())  // 条件：用户ID
                .set("status", dto.getStatus());  // 更新：状态字段


        boolean update = userService.update(updateWrapper);
        // 5. 根据更新结果返回响应
        if (update) {
            return Result.success("状态更新成功");
        } else {
            return Result.error("状态更新失败");
        }
    }
    public static class StatusUpdateDTO {
        @NotNull(message = "用户ID不能为空")
        private Integer id;  // 用户ID

        @NotNull(message = "状态值不能为空")
        private Integer status;  // 目标状态：0=禁用，1=启用

        // getter 和 setter
        public Integer getId() { return id; }
        public void setId(Integer id) { this.id = id; }
        public Integer getStatus() { return status; }
        public void setStatus(Integer status) { this.status = status; }
    }

    /**
     * 重置用户密码
     * 前端请求：POST /api/admin/resetPassword，请求体 {id: 1, password: "newPassword"}
     */
    @PostMapping("/resetPassword")
    public Result resetPassword(@Valid @RequestBody ResetPasswordDTO dto) {
        // 1. 校验密码长度（6-16位，与前端提示一致）
        if (dto.getPassword().length() < 6 || dto.getPassword().length() > 16) {
            return Result.error("密码长度必须在6-16个字符之间");
        }

        // 2. 检查用户是否存在
        User user = userService.getById(dto.getId());
        if (user == null) {
            return Result.error("用户不存在");
        }

        // 3. 密码加密（使用BCrypt不可逆加密）
        String encryptedPassword = passwordEncoder.encode(dto.getPassword());

        // 4. 更新密码（只更新password字段）
        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("id", dto.getId())
                .set("password", encryptedPassword);

        boolean update = userService.update(updateWrapper);

        // 5. 返回结果
        if (update) {
            return Result.success("密码重置成功");
        } else {
            return Result.error("密码重置失败");
        }
    }

    /**
     * 接收前端密码重置参数的DTO
     */
    public static class ResetPasswordDTO {
        @NotNull(message = "用户ID不能为空")
        private Integer id;  // 用户ID

        @NotBlank(message = "新密码不能为空")
        private String password;  // 新密码（明文）

        // getter和setter
        public Integer getId() { return id; }
        public void setId(Integer id) { this.id = id; }
        public String getPassword() { return password; }
        public void setPassword(String password) { this.password = password; }
    }



    @PostMapping("/order/list")
    public Result<?> listOrders(@RequestBody OrderQueryParam param) {
        return orderService.listOrders(param);
    }

    /**
     * 查询订单详情
     * @param orderId 订单ID
     */
    @GetMapping("/order/detail/{orderId}")
    public Result<OrderDetailDTO> getOrderDetail(@PathVariable Integer orderId) {
        return orderService.getOrderDetail(orderId);
    }

    /**
     * 处理异常订单
     * @param params 前端传递的参数（orderId、handleType、remark）
     */
    @PostMapping("/order/handleException")
    public Result<?> handleExceptionOrder(@RequestBody Map<String, Object> params) {
        Integer orderId = (Integer) params.get("orderId");
        String handleType = (String) params.get("handleType");
        String remark = (String) params.get("remark");
        return orderService.handleExceptionOrder(orderId, handleType, remark);
    }

    //商品审核列表
    // 商品审核列表查询接口（与前端fetchProductList对应）
    @GetMapping("/product/review/list") // 子路径：完整接口路径 = 父路径 + /list
    public Result<IPage<Product>> getProductReviewList(
            // @Valid 触发参数校验
            @Valid ProductReviewQueryDTO queryDTO
    ) {
        try {
            // 调用业务层获取分页数据
          IPage<Product> page= productService.queryProductList(queryDTO);
            return Result.success(page); // 成功响应
        } catch (Exception e) {
            // 异常捕获（实际项目建议用全局异常处理器）
            return Result.error("获取商品列表失败：" + e.getMessage());
        }
    }

    @GetMapping("/product/review/stats")
    public Result getReviewStats() {
        ProductReviewStatsDTO reviewStats = null;
        try {
            reviewStats = productService.getReviewStats();
        } catch (Exception e) {
            log.error("获取商品审核统计信息失败：" + e.getMessage());
            throw new RuntimeException(e);
        }
        return Result.success(reviewStats);
    }


    /**
     * 提交商品审核结果（通过/拒绝）
     */
    @PostMapping("/product/review/{productId}")
    public Result submitReview(
            @PathVariable Integer productId, // 路径参数：商品ID
            @Valid @RequestBody ReviewSubmitDTO reviewDTO // 请求体：审核状态和意见（自动校验）
    ) {
        // 调用服务层处理审核逻辑
        productService.handleReview(productId, reviewDTO);
        return Result.success("审核操作成功");
    }
    // 重置商品审核状态
    @PostMapping("/product/review/reset/{productId}")
    public Result resetReviewStatus(@PathVariable Integer productId) {
        productService.resetToPending(productId);
        return Result.success("已重置为待审核状态");
    }



}

